home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Contributed / WASTE / WASTE Pascal Interfaces / WASTE.p < prev    next >
Encoding:
Text File  |  2000-09-28  |  29.5 KB  |  988 lines  |  [TEXT/CWIE]
  1. UNIT WASTE;
  2.  
  3. { Pascal interface to the WASTE text engine }
  4.  
  5. { version 1.3 (January 1998) }
  6.  
  7. { Copyright © 1993-1998 Marco Piovanelli }
  8. { All Rights Reserved }
  9.  
  10. INTERFACE
  11.     USES
  12.         ConditionalMacros,
  13.         Types,
  14.         MixedMode,
  15.         QuickdrawText,
  16.         Quickdraw,
  17.         Script,
  18.         TextUtils,
  19.         TextEdit,
  20.         Drag,
  21.         LongCoords;
  22.  
  23. {$PUSH}
  24. {$ALIGN MAC68K}
  25. {$LibExport+}
  26.  
  27.     CONST
  28.  
  29. { result codes }
  30.  
  31.         weCantUndoErr = -10015;                    { undo buffer is clear (= errAECantUndo) }
  32.         weEmptySelectionErr = -10013;            { empty selection range (= errAENoUserSelection) }
  33.         weNotHandledErr = -1708;                { please use default behavior (= errAEEventNotHandled) }
  34.         weUnknownObjectTypeErr = -9478;            { specified object type is not registered }
  35.         weObjectNotFoundErr = -9477;            { no object found at specified offset }
  36.         weReadOnlyErr = -9476;                    { cannot modify instance }
  37.         weUndefinedSelectorErr = -50;            { unknown selector (= paramErr) }
  38.  
  39. { alignment styles }
  40.  
  41.         weFlushLeft = -2;                    { flush left }
  42.         weFlushRight = -1;                    { flush right }
  43.         weFlushDefault = 0;                    { flush according to system direction }
  44.         weCenter = 1;                        { centered }
  45.         weJustify = 2;                        { fully justified }
  46.  
  47. { primary line direction }
  48.  
  49.         weDirDefault = 1;                    { according to system direction }
  50.         weDirRightToLeft = -1;                { force right-to-left }
  51.         weDirLeftToRight = 0;                { force left-to-right }
  52.  
  53. { values for the mode parameter in WESetStyle and WEContinuousStyle }
  54.  
  55.         weDoFont                     = $0001;    { set font family number }
  56.         weDoFace                     = $0002;    { set Quickdraw styles }
  57.         weDoSize                     = $0004;    { set type size }
  58.         weDoColor                     = $0008;    { set color }
  59.         weDoAll                     = weDoFont + weDoFace + weDoSize + weDoColor;
  60.         weDoAddSize                 = $0010;    { adjust type size }
  61.         weDoToggleFace                 = $0020;    { turn a style off if it's continuous over the selection }
  62.         weDoReplaceFace             = $0040;    { replace existing styles outright }
  63.         weDoPreserveScript            = $0080;    { don't change scripts when applying a font change }
  64.         weDoExtractSubscript         = $0100;    { extract subscripts when applying a font change }
  65.         weDoFaceMask                 = $0200;    { set Quickdraw styles using mask field }
  66.  
  67. { values for the edge parameter in WEGetOffset etc. }
  68.  
  69.         kLeadingEdge = -1;            { point is on the leading edge of a glyph }
  70.         kTrailingEdge = 0;            { point is on the trailing edge of a glyph }
  71.         kObjectEdge = 2;            { point is in the middle of an embedded object }
  72.  
  73. { values for WEFeatureFlag feature parameter }
  74.  
  75.         weFAutoScroll                 = 0;            { automatically scroll the selection range into view }
  76.         weFOutlineHilite             = 2;            { frame selection when deactivated }
  77.         weFReadOnly                 = 5;            { disallow modifications }
  78.         weFUndo                     = 6;            { support WEUndo }
  79.         weFIntCutAndPaste             = 7;            { use intelligent cut-and-paste rules }
  80.         weFDragAndDrop                 = 8;            { support drag-and-drop text editing }
  81.         weFInhibitRecal             = 9;            { don't recalculate line starts and don't redraw text }
  82.         weFUseTempMem                 = 10;            { use temporary memory for main data structures }
  83.         weFDrawOffscreen             = 11;            { draw text offscreen for smoother visual results }
  84.         weFInhibitRedraw             = 12;            { don't redraw text }
  85.         weFMonoStyled                = 13;            { disallow style changes }
  86.         weFInhibitColor             = 31;            { draw in black & white only }
  87.  
  88. { values for WENew flags parameter }
  89.  
  90.         weDoAutoScroll                 = $00000001;
  91.         weDoOutlineHilite             = $00000004;
  92.         weDoReadOnly                 = $00000020;
  93.         weDoUndo                     = $00000040;
  94.         weDoIntCutAndPaste             = $00000080;
  95.         weDoDragAndDrop             = $00000100;
  96.         weDoInhibitRecal             = $00000200;
  97.         weDoUseTempMem                 = $00000400;
  98.         weDoDrawOffscreen             = $00000800;
  99.         weDoInhibitRedraw            = $00001000;
  100.         weDoMonoStyled                = $00002000;
  101.         weDoInhibitColor            = $80000000;
  102.  
  103. { values for WEFeatureFlag action parameter }
  104.  
  105.         weBitToggle = -2;        { toggles the specified feature }
  106.         weBitTest = -1;            { returns the current setting of the specified feature }
  107.         weBitClear = 0;            { disables the specified feature }
  108.         weBitSet = 1;            { enables the specified feature }
  109.  
  110. { values for WEGetInfo and WESetInfo selector parameter }
  111.  
  112.         weCharByteHook             = 'cbyt';    { CharByte hook }
  113.         weCharToPixelHook         = 'c2p ';    { CharToPixel hook }
  114.         weCharTypeHook             = 'ctyp';    { CharType hook }
  115.         weClickLoop             = 'clik';    { click loop callback }
  116.         weCurrentDrag             = 'drag';    { drag currently being tracked from WEClick }
  117.         weDrawTextHook             = 'draw';    { text drawing hook }
  118.         weEraseHook                = 'eras';    { background erasing hook }
  119.         weFluxProc                = 'flux';    { flux callback }
  120.         weHiliteDropAreaHook     = 'hidr';    { drop area highlighting hook }
  121.         weLineBreakHook         = 'lbrk';    { line breaking hook }
  122.         wePixelToCharHook         = 'p2c ';    { PixelToChar hook }
  123.         wePort                     = 'port';    { graphics port }
  124.         wePreTrackDragHook        = 'ptrk';    { pre-TrackDrag hook }
  125.         weRefCon                 = 'refc';    { reference constant for use by application }
  126.         weScrollProc             = 'scrl';    { scroll callback }
  127.         weText                     = 'text';    { handle to the raw text }
  128.         weTranslateDragHook     = 'xdrg';    { drag translation callback }
  129.         weTranslucencyThreshold    = 'tluc';    { area threshold for translucent drags }
  130.         weTSMDocumentID         = 'tsmd';    { Text Services Manager document ID }
  131.         weTSMPreUpdate             = 'pre ';    { Text Services Manager pre-update callback }
  132.         weTSMPostUpdate         = 'post';    { Text Services Manager post-update callback }
  133.         weURLHint                 = 'urlh';    { URL hint string for Internet Config }
  134.         weWordBreakHook         = 'wbrk';    { word breaking hook }
  135.  
  136. { values for WEInstallObjectHandler handlerSelector parameter }
  137.  
  138.         weNewHandler             = 'new ';    { new handler }
  139.         weDisposeHandler         = 'free';    { dispose handler }
  140.         weDrawHandler             = 'draw';    { draw handler }
  141.         weClickHandler             = 'clik';    { click handler }
  142.         weStreamHandler         = 'strm';    { stream handler }
  143.  
  144. { action kinds }
  145.  
  146.         weAKNone             = 0;    { null action }
  147.         weAKUnspecified     = 1;    { action of unspecified nature }
  148.         weAKTyping             = 2;    { some text has been typed in }
  149.         weAKCut             = 3;    { the selection range has been cut }
  150.         weAKPaste             = 4;    { something has been pasted }
  151.         weAKClear             = 5;    { the selection range has been deleted }
  152.         weAKDrag             = 6;    { drag and drop operation }
  153.         weAKSetStyle         = 7;    { some style has been applied to a text range }
  154.  
  155. { destination kinds for stream handler }
  156.  
  157.         weToScrap        =    0;
  158.         weToDrag        =    1;
  159.         weToSoup        =    2;
  160.  
  161.     TYPE
  162.  
  163. { WASTE data types }
  164.  
  165.         WEReference = Ptr;
  166.         WEObjectReference = Ptr;
  167.         WESoupHandle = Handle;
  168.         WEFontTableHandle = Handle;
  169.         WEActionKind = INTEGER;
  170.         WEAlignment = SignedByte;
  171.         WEDirection = INTEGER;
  172.         WEStyleMode = INTEGER;
  173.         WESelector = FourCharCode;
  174.         WEHandle = WEReference;        { obsolete; kept for backward compatibility }
  175.  
  176.         WERunInfo = RECORD
  177.                 runStart: LONGINT;                { byte offset to first character of style run }
  178.                 runEnd: LONGINT;                { byte offset past last character of style run }
  179.                 runHeight: INTEGER;                { line height (ascent + descent + leading) }
  180.                 runAscent: INTEGER;                { font ascent }
  181.                 runStyle: TextStyle;            { text attributes }
  182.                 runObject: WEObjectReference;    { either NIL or reference to embedded object }
  183.             END;  { WERunInfo }
  184.  
  185. { callback prototypes }
  186.  
  187. { FUNCTION MyClickLoop (we: WEReference): BOOLEAN; }
  188.         WEClickLoopProcPtr = ProcPtr;
  189.         WEClickLoopUPP = UniversalProcPtr;
  190.  
  191. { PROCEDURE MyScrollProc (we: WEReference); }
  192.         WEScrollProcPtr = ProcPtr;
  193.         WEScrollUPP = UniversalProcPtr;
  194.  
  195. { PROCEDURE MyTSMPreUpdate (we: WEReference); }
  196.         WETSMPreUpdateProcPtr = ProcPtr;
  197.         WETSMPreUpdateUPP = UniversalProcPtr;
  198.  
  199. { PROCEDURE MyTSMPostUpdate (we: WEReference; fixLength: LONGINT; }
  200. {         inputAreaStart, inputAreaEnd: LONGINT; }
  201. {        pinRangeStart, pinRangeEnd: LONGINT); }
  202.         WETSMPostUpdateProcPtr = ProcPtr;
  203.         WETSMPostUpdateUPP = UniversalProcPtr;
  204.  
  205. { FUNCTION MyPreTrackDrag (theDrag: DragReference; we: WEReference): OSErr; }
  206.         WEPreTrackDragProcPtr = ProcPtr;
  207.         WEPreTrackDragUPP = UniversalProcPtr;
  208.  
  209. { FUNCTION MyTranslateDrag (theDrag: DragReference; theItem: ItemReference; }
  210. {         requestedType: FlavorType; putDataHere: Handle; }
  211. {        dropOffset: LONGINT; we: WEReference): OSErr; }
  212.         WETranslateDragProcPtr = ProcPtr;
  213.         WETranslateDragUPP = UniversalProcPtr;
  214.  
  215. { FUNCTION MyHiliteDropArea (theDrag: DragReference; hiliteFlag: BOOLEAN; }
  216. {        we: WEReference): OSErr; }
  217.         WEHiliteDropAreaProcPtr = ProcPtr;
  218.         WEHiliteDropAreaUPP = UniversalProcPtr;
  219.  
  220. { FUNCTION MyFontIDToName (fontID: INTEGER; VAR fontName: Str255): OSErr; }
  221.         WEFontIDToNameProcPtr = ProcPtr;
  222.         WEFontIDToNameUPP = UniversalProcPtr;
  223.  
  224. { FUNCTION MyFontNameToID (fontName: Str255; oldFontID: INTEGER; }
  225. {        VAR newFontID: INTEGER): OSErr; }
  226.         WEFontNameToIDProcPtr = ProcPtr;
  227.         WEFontNameToIDUPP = UniversalProcPtr;
  228.  
  229. { PROCEDURE MyDrawText (pText: Ptr; textLength: LONGINT; slop: Fixed; }
  230. {         styleRunPosition: JustStyleCode; we: WEReference); }
  231.         WEDrawTextProcPtr = ProcPtr;
  232.         WEDrawTextUPP = UniversalProcPtr;
  233.  
  234. { FUNCTION MyPixelToChar (pText: Ptr; textLength: LONGINT; slop: Fixed; }
  235. {         VAR pixelWidth: Fixed; VAR edge: SignedByte; }
  236. {         styleRunPosition: JustStyleCode; hPos: Fixed; we: WEReference): LONGINT; }
  237.         WEPixelToCharProcPtr = ProcPtr;
  238.         WEPixelToCharUPP = UniversalProcPtr;
  239.  
  240. { FUNCTION MyCharToPixel (pText: Ptr; textLength: LONGINT; slop: Fixed; }
  241. {        offset: LONGINT; direction: INTEGER; }
  242. {        styleRunPosition: JustStyleCode; hPos: INTEGER; we:WEReference): INTEGER; }
  243.         WECharToPixelProcPtr = ProcPtr;
  244.         WECharToPixelUPP = UniversalProcPtr;
  245.  
  246. { FUNCTION MyLineBreak (pText: Ptr; textLength: LONGINT; }
  247. {        textStart, textEnd: LONGINT; VAR textWidth: Fixed; VAR textOffset: LONGINT; }
  248. {        we: WEReference): StyledLineBreakCode; }
  249.         WELineBreakProcPtr = ProcPtr;
  250.         WELineBreakUPP = UniversalProcPtr;
  251.  
  252. { PROCEDURE MyWordBreak (pText: Ptr; textLength, offset: INTEGER; edge: SignedByte; }
  253. {                    VAR breakOffsets: OffsetTable; script: ScriptCode; we: WEReference); }
  254.         WEWordBreakProcPtr = ProcPtr;
  255.         WEWordBreakUPP = UniversalProcPtr;
  256.  
  257. { FUNCTION MyCharByte (pText: Ptr; textOffset: INTEGER; }
  258. {                     script: ScriptCode; we: WEReference): INTEGER; }
  259.         WECharByteProcPtr = ProcPtr;
  260.         WECharByteUPP = UniversalProcPtr;
  261.  
  262. { FUNCTION MyCharType (pText: Ptr; textOffset: INTEGER; }
  263. {                     script: ScriptCode; we: WEReference): INTEGER; }
  264.         WECharTypeProcPtr = ProcPtr;
  265.         WECharTypeUPP = UniversalProcPtr;
  266.  
  267. { PROCEDURE MyErase (VAR area: Rect; we: WEReference); }
  268.         WEEraseProcPtr = ProcPtr;
  269.         WEEraseUPP = UniversalProcPtr;
  270.  
  271. { PROCEDURE MyFlux (offset: LONGINT; delta: LONGINT; we: WEReference); }
  272.         WEFluxProcPtr = ProcPtr;
  273.         WEFluxUPP = UniversalProcPtr;
  274.  
  275. { FUNCTION MyNewObject (VAR defaultObjectSize: Point; }
  276. {                    objectRef: WEObjectReference): OSErr; }
  277.         WENewObjectProcPtr = ProcPtr;
  278.         WENewObjectUPP = UniversalProcPtr;
  279.  
  280. { FUNCTION MyDisposeObject (objectRef: WEObjectReference): OSErr; }
  281.         WEDisposeObjectProcPtr = ProcPtr;
  282.         WEDisposeObjectUPP = UniversalProcPtr;
  283.  
  284. { FUNCTION MyDrawObject (VAR destRect: Rect; }
  285. {         objectRef: WEObjectReference): OSErr }
  286.         WEDrawObjectProcPtr = ProcPtr;
  287.         WEDrawObjectUPP = UniversalProcPtr;
  288.  
  289. { FUNCTION MyClickObject (hitPt: Point; modifiers: EventModifiers; clickTime: LONGINT; }
  290. {         objectRef: WEObjectReference): BOOLEAN; }
  291.         WEClickObjectProcPtr = ProcPtr;
  292.         WEClickObjectUPP = UniversalProcPtr;
  293.  
  294. { FUNCTION MyStreamObject (destKind: INTEGER; VAR theType: FlavorType; }
  295. {        putDataHere: Handle; objectRef: WEObjectReference): OSErr; }
  296.         WEStreamObjectProcPtr = ProcPtr;
  297.         WEStreamObjectUPP = UniversalProcPtr;
  298.  
  299.     CONST
  300.  
  301. { UPP proc info }
  302.  
  303.         uppWEClickLoopProcInfo             = $000000D0;
  304.         uppWEScrollProcInfo             = $000000C0;
  305.         uppWETSMPreUpdateProcInfo         = $000000C0;
  306.         uppWETSMPostUpdateProcInfo         = $0003FFC0;
  307.         uppWEPreTrackDragProcInfo        = $000003E0;
  308.         uppWETranslateDragProcInfo         = $0003FFE0;
  309.         uppWEHiliteDropAreaProcInfo     = $00000DE0;
  310.         uppWEFontIDToNameProcInfo        = $000003A0;
  311.         uppWEFontNameToIDProcInfo        = $00000EE0;
  312.         uppWEDrawTextProcInfo             = $0000EFC0;
  313.         uppWEPixelToCharProcInfo         = $003EFFF0;
  314.         uppWECharToPixelProcInfo         = $003ABFE0;
  315.         uppWELineBreakProcInfo             = $000FFFD0;
  316.         uppWEWordBreakProcInfo             = $000EDAC0;
  317.         uppWECharByteProcInfo             = $00003AE0;
  318.         uppWECharTypeProcInfo             = $00003AE0;
  319.         uppWEEraseProcInfo                = $000003C0;
  320.         uppWEFluxProcInfo                = $00000FC0;
  321.         uppWENewObjectProcInfo             = $000003E0;
  322.         uppWEDisposeObjectProcInfo         = $000000E0;
  323.         uppWEDrawObjectProcInfo         = $000003E0;
  324.         uppWEClickObjectProcInfo         = $00003ED0;
  325.         uppWEStreamObjectProcInfo         = $00003FA0;
  326.  
  327. { NewProc macros }
  328.  
  329.     FUNCTION NewWEClickLoopProc (userRoutine: WEClickLoopProcPtr): WEClickLoopUPP;
  330. {$IFC NOT GENERATINGCFM}
  331.     INLINE
  332.         $2E9F;
  333. {$ENDC}
  334.  
  335.     FUNCTION NewWEScrollProc (userRoutine: WEScrollProcPtr): WEScrollUPP;
  336. {$IFC NOT GENERATINGCFM}
  337.     INLINE
  338.         $2E9F;
  339. {$ENDC}
  340.  
  341.     FUNCTION NewWETSMPreUpdateProc (userRoutine: WETSMPreUpdateProcPtr): WETSMPreUpdateUPP;
  342. {$IFC NOT GENERATINGCFM}
  343.     INLINE
  344.         $2E9F;
  345. {$ENDC}
  346.  
  347.     FUNCTION NewWETSMPostUpdateProc (userRoutine: WETSMPostUpdateProcPtr): WETSMPostUpdateUPP;
  348. {$IFC NOT GENERATINGCFM}
  349.     INLINE
  350.         $2E9F;
  351. {$ENDC}
  352.  
  353.     FUNCTION NewWEPreTrackDragProc (userRoutine: WEPreTrackDragProcPtr): WEPreTrackDragUPP;
  354. {$IFC NOT GENERATINGCFM}
  355.     INLINE
  356.         $2E9F;
  357. {$ENDC}
  358.  
  359.     FUNCTION NewWETranslateDragProc (userRoutine: WETranslateDragProcPtr): WETranslateDragUPP;
  360. {$IFC NOT GENERATINGCFM}
  361.     INLINE
  362.         $2E9F;
  363. {$ENDC}
  364.  
  365.     FUNCTION NewWEHiliteDropAreaProc (userRoutine: WEHiliteDropAreaProcPtr): WEHiliteDropAreaUPP;
  366. {$IFC NOT GENERATINGCFM}
  367.     INLINE
  368.         $2E9F;
  369. {$ENDC}
  370.  
  371.     FUNCTION NewWEFontIDToNameProc (userRoutine: WEFontIDToNameProcPtr): WEFontIDToNameUPP;
  372. {$IFC NOT GENERATINGCFM}
  373.     INLINE
  374.         $2E9F;
  375. {$ENDC}
  376.  
  377.     FUNCTION NewWEFontNameToIDProc (userRoutine: WEFontNameToIDProcPtr): WEFontNameToIDUPP;
  378. {$IFC NOT GENERATINGCFM}
  379.     INLINE
  380.         $2E9F;
  381. {$ENDC}
  382.  
  383.     FUNCTION NewWEDrawTextProc (userRoutine: WEDrawTextProcPtr): WEDrawTextUPP;
  384. {$IFC NOT GENERATINGCFM}
  385.     INLINE
  386.         $2E9F;
  387. {$ENDC}
  388.  
  389.     FUNCTION NewWEPixelToCharProc (userRoutine: WEPixelToCharProcPtr): WEPixelToCharUPP;
  390. {$IFC NOT GENERATINGCFM}
  391.     INLINE
  392.         $2E9F;
  393. {$ENDC}
  394.  
  395.     FUNCTION NewWECharToPixelProc (userRoutine: WECharToPixelProcPtr): WECharToPixelUPP;
  396. {$IFC NOT GENERATINGCFM}
  397.     INLINE
  398.         $2E9F;
  399. {$ENDC}
  400.  
  401.     FUNCTION NewWELineBreakProc (userRoutine: WELineBreakProcPtr): WELineBreakUPP;
  402. {$IFC NOT GENERATINGCFM}
  403.     INLINE
  404.         $2E9F;
  405. {$ENDC}
  406.  
  407.     FUNCTION NewWEWordBreakProc (userRoutine: WEWordBreakProcPtr): WEWordBreakUPP;
  408. {$IFC NOT GENERATINGCFM}
  409.     INLINE
  410.         $2E9F;
  411. {$ENDC}
  412.  
  413.     FUNCTION NewWECharByteProc (userRoutine: WECharByteProcPtr): WECharByteUPP;
  414. {$IFC NOT GENERATINGCFM}
  415.     INLINE
  416.         $2E9F;
  417. {$ENDC}
  418.  
  419.     FUNCTION NewWECharTypeProc (userRoutine: WECharTypeProcPtr): WECharTypeUPP;
  420. {$IFC NOT GENERATINGCFM}
  421.     INLINE
  422.         $2E9F;
  423. {$ENDC}
  424.  
  425.     FUNCTION NewWEEraseProc (userRoutine: WEEraseProcPtr): WEEraseUPP;
  426. {$IFC NOT GENERATINGCFM}
  427.     INLINE
  428.         $2E9F;
  429. {$ENDC}
  430.  
  431.     FUNCTION NewWEFluxProc (userRoutine: WEFluxProcPtr): WEFluxUPP;
  432. {$IFC NOT GENERATINGCFM}
  433.     INLINE
  434.         $2E9F;
  435. {$ENDC}
  436.  
  437.     FUNCTION NewWENewObjectProc (userRoutine: WENewObjectProcPtr): WENewObjectUPP;
  438. {$IFC NOT GENERATINGCFM}
  439.     INLINE
  440.         $2E9F;
  441. {$ENDC}
  442.  
  443.     FUNCTION NewWEDisposeObjectProc (userRoutine: WEDisposeObjectProcPtr): WEDisposeObjectUPP;
  444. {$IFC NOT GENERATINGCFM}
  445.     INLINE
  446.         $2E9F;
  447. {$ENDC}
  448.  
  449.     FUNCTION NewWEDrawObjectProc (userRoutine: WEDrawObjectProcPtr): WEDrawObjectUPP;
  450. {$IFC NOT GENERATINGCFM}
  451.     INLINE
  452.         $2E9F;
  453. {$ENDC}
  454.  
  455.     FUNCTION NewWEClickObjectProc (userRoutine: WEClickObjectProcPtr): WEClickObjectUPP;
  456. {$IFC NOT GENERATINGCFM}
  457.     INLINE
  458.         $2E9F;
  459. {$ENDC}
  460.  
  461.     FUNCTION NewWEStreamObjectProc (userRoutine: WEStreamObjectProcPtr): WEStreamObjectUPP;
  462. {$IFC NOT GENERATINGCFM}
  463.     INLINE
  464.         $2E9F;
  465. {$ENDC}
  466.  
  467. { CallProc macros }
  468.  
  469.     FUNCTION CallWEClickLoopProc (we: WEReference;
  470.                                     userRoutine: WEClickLoopUPP): BOOLEAN;
  471. {$IFC NOT GENERATINGCFM}
  472.     INLINE
  473.         $205F, $4E90;
  474. {$ENDC}
  475.  
  476.     PROCEDURE CallWEScrollProc (we: WEReference;
  477.                                     userRoutine: WEScrollUPP);
  478. {$IFC NOT GENERATINGCFM}
  479.     INLINE
  480.         $205F, $4E90;
  481. {$ENDC}
  482.  
  483.     PROCEDURE CallWETSMPreUpdateProc (we: WEReference;
  484.                                     userRoutine: WETSMPreUpdateUPP);
  485. {$IFC NOT GENERATINGCFM}
  486.     INLINE
  487.         $205F, $4E90;
  488. {$ENDC}
  489.  
  490.     PROCEDURE CallWETSMPostUpdateProc (we: WEReference;
  491.                                     fixLength: LONGINT;
  492.                                     inputAreaStart, inputAreaEnd: LONGINT;
  493.                                     pinRangeStart, pinRangeEnd: LONGINT;
  494.                                     userRoutine: WETSMPostUpdateUPP);
  495. {$IFC NOT GENERATINGCFM}
  496.     INLINE
  497.         $205F, $4E90;
  498. {$ENDC}
  499.  
  500.     FUNCTION CallWEPreTrackDragProc (theDrag: DragReference;
  501.                                     we: WEReference;
  502.                                     userRoutine: WEPreTrackDragUPP): OSErr;
  503. {$IFC NOT GENERATINGCFM}
  504.     INLINE
  505.         $205F, $4E90;
  506. {$ENDC}
  507.  
  508.     FUNCTION CallWETranslateDragProc (theDrag: DragReference;
  509.                                     theItem: ItemReference;
  510.                                     requestedType: FlavorType;
  511.                                     putDataHere: Handle;
  512.                                     dropOffset: LONGINT;
  513.                                     we: WEReference;
  514.                                     userRoutine: WETranslateDragUPP): OSErr;
  515. {$IFC NOT GENERATINGCFM}
  516.     INLINE
  517.         $205F, $4E90;
  518. {$ENDC}
  519.  
  520.     FUNCTION CallWEHiliteDropAreaProc (theDrag: DragReference;
  521.                                     hiliteFlag: BOOLEAN;
  522.                                     we: WEReference;
  523.                                     userRoutine: WEHiliteDropAreaUPP): OSErr;
  524. {$IFC NOT GENERATINGCFM}
  525.     INLINE
  526.         $205F, $4E90;
  527. {$ENDC}
  528.  
  529.     FUNCTION CallWEFontIDToNameProc (fontID: INTEGER;
  530.                                     VAR fontName: Str255;
  531.                                     userRoutine: WEFontIDToNameUPP): OSErr;
  532. {$IFC NOT GENERATINGCFM}
  533.     INLINE
  534.         $205F, $4E90;
  535. {$ENDC}
  536.  
  537.     FUNCTION CallWEFontNameToIDProc ({CONST} VAR fontName: Str255;
  538.                                     oldFontID: INTEGER;
  539.                                     VAR newFontID: INTEGER;
  540.                                     userRoutine: WEFontNameToIDUPP): OSErr;
  541. {$IFC NOT GENERATINGCFM}
  542.     INLINE
  543.         $205F, $4E90;
  544. {$ENDC}
  545.  
  546.     PROCEDURE CallWEDrawTextProc (pText: Ptr;
  547.                                     textLength: LONGINT;
  548.                                     slop: Fixed;
  549.                                     styleRunPosition: JustStyleCode;
  550.                                     we: WEReference;
  551.                                     userRoutine: WEDrawTextUPP);
  552. {$IFC NOT GENERATINGCFM}
  553.     INLINE
  554.         $205F, $4E90;
  555. {$ENDC}
  556.  
  557.     FUNCTION CallWEPixelToCharProc (pText: Ptr;
  558.                                     textLength: LONGINT;
  559.                                     slop: Fixed;
  560.                                     VAR width: Fixed;
  561.                                     VAR edge: SignedByte;
  562.                                     styleRunPosition: JustStyleCode;
  563.                                     hPos: Fixed;
  564.                                     we: WEReference;
  565.                                     userRoutine: WEPixelToCharUPP): LONGINT;
  566. {$IFC NOT GENERATINGCFM}
  567.     INLINE
  568.         $205F, $4E90;
  569. {$ENDC}
  570.  
  571.     FUNCTION CallWECharToPixelProc (pText: Ptr;
  572.                                     textLength: LONGINT;
  573.                                     slop: Fixed;
  574.                                     offset: LONGINT;
  575.                                     direction: INTEGER;
  576.                                     styleRunPosition: JustStyleCode;
  577.                                     hPos: INTEGER;
  578.                                     we: WEReference;
  579.                                     userRoutine: WECharToPixelUPP): INTEGER;
  580. {$IFC NOT GENERATINGCFM}
  581.     INLINE
  582.         $205F, $4E90;
  583. {$ENDC}
  584.  
  585.     FUNCTION CallWELineBreakProc (pText: Ptr;
  586.                                     textLength: LONGINT;
  587.                                     textStart, textEnd: LONGINT;
  588.                                     VAR textWidth: Fixed;
  589.                                     VAR textOffset: LONGINT;
  590.                                     we: WEReference;
  591.                                     userRoutine: WELineBreakUPP): StyledLineBreakCode;
  592. {$IFC NOT GENERATINGCFM}
  593.     INLINE
  594.         $205F, $4E90;
  595. {$ENDC}
  596.  
  597.     PROCEDURE CallWEWordBreakProc (pText: Ptr;
  598.                                     textLength, offset: INTEGER;
  599.                                     edge: SignedByte;
  600.                                     VAR breakOffsets: OffsetTable;
  601.                                     script: ScriptCode;
  602.                                     we: WEReference;
  603.                                     userRoutine: WEWordBreakUPP);
  604. {$IFC NOT GENERATINGCFM}
  605.     INLINE
  606.         $205F, $4E90;
  607. {$ENDC}
  608.  
  609.     FUNCTION CallWECharByteProc (pText: Ptr;
  610.                                     textOffset: INTEGER;
  611.                                     script: ScriptCode;
  612.                                     we: WEReference;
  613.                                     userRoutine: WECharByteUPP): INTEGER;
  614. {$IFC NOT GENERATINGCFM}
  615.     INLINE
  616.         $205F, $4E90;
  617. {$ENDC}
  618.  
  619.     FUNCTION CallWECharTypeProc (pText: Ptr;
  620.                                     textOffset: INTEGER;
  621.                                     script: ScriptCode;
  622.                                     we: WEReference;
  623.                                     userRoutine: WECharTypeUPP): INTEGER;
  624. {$IFC NOT GENERATINGCFM}
  625.     INLINE
  626.         $205F, $4E90;
  627. {$ENDC}
  628.  
  629.     PROCEDURE CallWEEraseProc ({CONST} VAR area: Rect;
  630.                                     we: WEReference;
  631.                                     userRoutine: WEEraseUPP);
  632. {$IFC NOT GENERATINGCFM}
  633.     INLINE
  634.         $205F, $4E90;
  635. {$ENDC}
  636.  
  637.     PROCEDURE CallWEFluxProc (offset: LONGINT;
  638.                                     delta: LONGINT;
  639.                                     we: WEReference;
  640.                                     userRoutine: WEFluxUPP);
  641. {$IFC NOT GENERATINGCFM}
  642.     INLINE
  643.         $205F, $4E90;
  644. {$ENDC}
  645.  
  646.     FUNCTION CallWENewObjectProc (VAR defaultObjectSize: Point;
  647.                                     objectRef: WEObjectReference;
  648.                                     userRoutine: WENewObjectUPP): OSErr;
  649. {$IFC NOT GENERATINGCFM}
  650.     INLINE
  651.         $205F, $4E90;
  652. {$ENDC}
  653.  
  654.     FUNCTION CallWEDisposeObjectProc (objectRef: WEObjectReference;
  655.                                     userRoutine: WEDisposeObjectUPP): OSErr;
  656. {$IFC NOT GENERATINGCFM}
  657.     INLINE
  658.         $205F, $4E90;
  659. {$ENDC}
  660.  
  661.     FUNCTION CallWEDrawObjectProc ({CONST} VAR destRect: Rect;
  662.                                     objectRef: WEObjectReference;
  663.                                     userRoutine: WEDrawObjectUPP): OSErr;
  664. {$IFC NOT GENERATINGCFM}
  665.     INLINE
  666.         $205F, $4E90;
  667. {$ENDC}
  668.  
  669.     FUNCTION CallWEClickObjectProc (hitPoint: Point;
  670.                                     modifiers: EventModifiers;
  671.                                     clickTime: LONGINT;
  672.                                     objectRef: WEObjectReference;
  673.                                     userRoutine: WEClickObjectUPP): BOOLEAN;
  674. {$IFC NOT GENERATINGCFM}
  675.     INLINE
  676.         $205F, $4E90;
  677. {$ENDC}
  678.  
  679.     FUNCTION CallWEStreamObjectProc (destKind: INTEGER;
  680.                                     VAR theType: FlavorType;
  681.                                     putDataHere: Handle;
  682.                                     objectRef: WEObjectReference;
  683.                                     userRoutine: WEStreamObjectUPP): OSErr;
  684. {$IFC NOT GENERATINGCFM}
  685.     INLINE
  686.         $205F, $4E90;
  687. {$ENDC}
  688.  
  689.  
  690. { WASTE PUBLIC CALLS }
  691.  
  692. { getting the shared library version number }
  693.  
  694.     FUNCTION WEVersion: NumVersion;
  695.  
  696. { creation and destruction }
  697.  
  698.     FUNCTION WENew ({CONST} VAR destRect, viewRect: LongRect;
  699.                                     flags: LONGINT;
  700.                                     VAR we: WEReference): OSErr;
  701.     PROCEDURE WEDispose (we: WEReference);
  702.  
  703. { getting variables }
  704.  
  705.     FUNCTION WEGetText (we: WEReference): Handle;
  706.     FUNCTION WEGetChar (offset: LONGINT;
  707.                                     we: WEReference): CHAR;
  708.     FUNCTION WEGetTextLength (we: WEReference): LONGINT;
  709.     FUNCTION WEGetHeight (startLine, endLine: LONGINT;
  710.                                     we: WEReference): LONGINT;
  711.     PROCEDURE WEGetSelection (VAR selStart, selEnd: LONGINT;
  712.                                     we: WEReference);
  713.     PROCEDURE WEGetDestRect (VAR destRect: LongRect;
  714.                                     we: WEReference);
  715.     PROCEDURE WEGetViewRect (VAR viewRect: LongRect;
  716.                                     we: WEReference);
  717.     FUNCTION WEIsActive (we: WEReference): BOOLEAN;
  718.     FUNCTION WEOffsetToLine (offset: LONGINT;
  719.                                     we: WEReference): LONGINT;
  720.     PROCEDURE WEGetLineRange (lineNo: LONGINT;
  721.                                     VAR lineStart, lineEnd: LONGINT;
  722.                                     we: WEReference);
  723.     FUNCTION WECountLines (we: WEReference): LONGINT;
  724.     FUNCTION WEOffsetToRun (offset: LONGINT;
  725.                                     we: WEReference): LONGINT;
  726.     PROCEDURE WEGetRunRange (runIndex: LONGINT;
  727.                                     VAR runStart, runEnd: LONGINT;
  728.                                     we: WEReference);
  729.     FUNCTION WECountRuns (we: WEReference): LONGINT;
  730.     FUNCTION WEGetClickCount (we: WEReference): INTEGER;
  731.  
  732. { setting variables }
  733.  
  734.     PROCEDURE WESetSelection (selStart, selEnd: LONGINT;
  735.                                     we: WEReference);
  736.     PROCEDURE WESetDestRect ({CONST} VAR destRect: LongRect;
  737.                                     we: WEReference);
  738.     PROCEDURE WESetViewRect ({CONST} VAR viewRect: LongRect;
  739.                                     we: WEReference);
  740.  
  741. { accessing style run information }
  742.  
  743.     FUNCTION WEContinuousStyle (VAR mode: WEStyleMode;
  744.                                     VAR ts: TextStyle;
  745.                                     we: WEReference): BOOLEAN;
  746.     PROCEDURE WEGetRunInfo (offset: LONGINT;
  747.                                     VAR info: WERunInfo;
  748.                                     we: WEReference);
  749.     FUNCTION WEGetRunDirection (offset: LONGINT;
  750.                                     we: WEReference): BOOLEAN;
  751.  
  752. { converting byte offsets to screen positions and vice versa }
  753.  
  754.     FUNCTION WEGetOffset ({CONST} VAR thePoint: LongPt;
  755.                                     VAR edge: SignedByte;
  756.                                     we: WEReference): LONGINT;
  757.     PROCEDURE WEGetPoint (offset: LONGINT;
  758.                                     direction: INTEGER;
  759.                                     VAR thePoint: LongPt;
  760.                                     VAR lineHeight: INTEGER;
  761.                                     we: WEReference);
  762.  
  763. { finding words, lines and paragraphs }
  764.  
  765.     PROCEDURE WEFindWord (offset: LONGINT;
  766.                                     edge: SignedByte;
  767.                                     VAR wordStart, wordEnd: LONGINT;
  768.                                     we: WEReference);
  769.     PROCEDURE WEFindLine (offset: LONGINT;
  770.                                     edge: SignedByte;
  771.                                     VAR lineStart, lineEnd: LONGINT;
  772.                                     we: WEReference);
  773.     PROCEDURE WEFindParagraph (offset: LONGINT;
  774.                                     edge: SignedByte;
  775.                                     VAR paragraphStart, paragraphEnd: LONGINT;
  776.                                     we: WEReference);
  777.  
  778. { making a copy of a text range }
  779.  
  780.     FUNCTION WECopyRange (rangeStart, rangeEnd: LONGINT;
  781.                                     hText: Handle;
  782.                                     hStyles: StScrpHandle;
  783.                                     hSoup: WESoupHandle;
  784.                                     we: WEReference): OSErr;
  785.  
  786. { getting and setting the alignment style }
  787.  
  788.     FUNCTION WEGetAlignment (we: WEReference): WEAlignment;
  789.     PROCEDURE WESetAlignment (alignment: WEAlignment;
  790.                                     we: WEReference);
  791.  
  792. { getting and setting the primary line direction }
  793.  
  794.     FUNCTION WEGetDirection (we: WEReference): WEDirection;
  795.     PROCEDURE WESetDirection (direction: WEDirection;
  796.                                     we: WEReference);
  797.  
  798. { recalculating line breaks, drawing and scrolling }
  799.  
  800.     FUNCTION WECalText (we: WEReference): OSErr;
  801.     PROCEDURE WEUpdate (updateRgn: RgnHandle;
  802.                                     we: WEReference);
  803.     PROCEDURE WEScroll (hOffset, vOffset: LONGINT;
  804.                                     we: WEReference);
  805.     PROCEDURE WESelView (we: WEReference);
  806.  
  807. { handling activate/deactivate events }
  808.  
  809.     PROCEDURE WEActivate (we: WEReference);
  810.     PROCEDURE WEDeactivate (we: WEReference);
  811.  
  812. { handling key-down events }
  813.  
  814.     PROCEDURE WEKey (key: CHAR;
  815.                                     modifiers: EventModifiers;
  816.                                     we: WEReference);
  817.  
  818. { handling mouse-down events and mouse tracking }
  819.  
  820.     PROCEDURE WEClick (hitPt: Point;
  821.                                     modifiers: EventModifiers;
  822.                                     clickTime: LONGINT;
  823.                                     we: WEReference);
  824.  
  825. { adjusting the cursor shape }
  826.  
  827.     FUNCTION WEAdjustCursor (mouseLoc: Point;
  828.                                     mouseRgn: RgnHandle;
  829.                                     we: WEReference): BOOLEAN;
  830.  
  831. { blinking the caret }
  832.  
  833.     PROCEDURE WEIdle (VAR maxSleep: LONGINT;
  834.                                     we: WEReference);
  835.  
  836. { modifying the text and the styles }
  837.  
  838.     FUNCTION WEInsert (pText: Ptr;
  839.                                     textLength: LONGINT;
  840.                                     hStyles: StScrpHandle;
  841.                                     hSoup: WESoupHandle;
  842.                                     we: WEReference): OSErr;
  843.     FUNCTION WEDelete (we: WEReference): OSErr;
  844.     FUNCTION WESetStyle (mode: WEStyleMode;
  845.                                     {CONST} VAR ts: TextStyle;
  846.                                     we: WEReference): OSErr;
  847.     FUNCTION WEUseText (hText: Handle;
  848.                                     we: WEReference): OSErr;
  849.     FUNCTION WEUseStyleScrap (hStyles: StScrpHandle;
  850.                                     we: WEReference): OSErr;
  851.  
  852. { undo }
  853.  
  854.     FUNCTION WEUndo (we: WEReference): OSErr;
  855.     PROCEDURE WEClearUndo (we: WEReference);
  856.     FUNCTION WEGetUndoInfo (VAR redoFlag: BOOLEAN;
  857.                                     we: WEReference): WEActionKind;
  858.     FUNCTION WEIsTyping (we: WEReference): BOOLEAN;
  859.     FUNCTION WEBeginAction (we: WEReference): OSErr;
  860.     FUNCTION WEEndAction (actionKind: WEActionKind;
  861.                                     we: WEReference): OSErr;
  862.  
  863. { keeping track of changes }
  864.  
  865.     FUNCTION WEGetModCount (we: WEReference): LONGINT;
  866.     PROCEDURE WEResetModCount (we: WEReference);
  867.  
  868. { embedded objects }
  869.  
  870.     FUNCTION WEInstallObjectHandler (objectType: FlavorType;
  871.                                     handlerSelector: WESelector;
  872.                                     handler: ProcPtr;
  873.                                     we: WEReference): OSErr;
  874.     FUNCTION WEGetObjectHandler (objectType: FlavorType;
  875.                                     handlerSelector: WESelector;
  876.                                     VAR handler: ProcPtr;
  877.                                     we: WEReference): OSErr;
  878.     FUNCTION WEInsertObject (objectType: FlavorType;
  879.                                     objectDataHandle: Handle;
  880.                                     objectSize: Point;        { (0, 0) means default size }
  881.                                     we: WEReference): OSErr;
  882.     FUNCTION WEGetSelectedObject (VAR objectRef: WEObjectReference;
  883.                                     we: WEReference): OSErr;
  884.     FUNCTION WEFindNextObject (offset: LONGINT;
  885.                                     VAR objectRef: WEObjectReference;
  886.                                     we: WEReference): LONGINT;
  887.     FUNCTION WEUseSoup (hSoup: WESoupHandle;
  888.                                     we: WEReference): OSErr;
  889.  
  890. { accessing embedded object attributes }
  891.  
  892.     FUNCTION WEGetObjectType (objectRef: WEObjectReference): FlavorType;
  893.     FUNCTION WEGetObjectDataHandle (objectRef: WEObjectReference): Handle;
  894.     FUNCTION WEGetObjectSize (objectRef: WEObjectReference): Point;
  895.     FUNCTION WEGetObjectOwner (objectRef: WEObjectReference): WEReference;
  896.     FUNCTION WEGetObjectRefCon (objectRef: WEObjectReference): LONGINT;
  897.     PROCEDURE WESetObjectRefCon (objectRef: WEObjectReference;
  898.                                     refCon: LONGINT);
  899.  
  900. { Clipboard operations }
  901.  
  902.     FUNCTION WECut (we: WEReference): OSErr;
  903.     FUNCTION WECopy (we: WEReference): OSErr;
  904.     FUNCTION WEPaste (we: WEReference): OSErr;
  905.     FUNCTION WECanPaste (we: WEReference): BOOLEAN;
  906.  
  907. { Drag Manager support }
  908.  
  909.     FUNCTION WEGetHiliteRgn (rangeStart, rangeEnd: LONGINT;
  910.                                     we: WEReference): RgnHandle;
  911.     FUNCTION WETrackDrag (message: DragTrackingMessage;
  912.                                     drag: DragReference;
  913.                                     we: WEReference): OSErr;
  914.     FUNCTION WEReceiveDrag (drag: DragReference;
  915.                                     we: WEReference): OSErr;
  916.     FUNCTION WECanAcceptDrag (drag: DragReference;
  917.                                     we: WEReference): BOOLEAN;
  918.     FUNCTION WEDraggedToTrash (drag: DragReference): BOOLEAN;
  919.  
  920. { font tables }
  921.  
  922.     FUNCTION WEBuildFontTable (hFontTable: WEFontTableHandle;
  923.                                     fontIDToNameProc: WEFontIDToNameUPP;
  924.                                     we: WEReference): OSErr;
  925.     FUNCTION WEUpdateFontTable (hFontTable: WEFontTableHandle;
  926.                                     fontNameToIDProc: WEFontNameToIDUPP;
  927.                                     VAR wasChanged: BOOLEAN): OSErr;
  928.     FUNCTION WEUpdateStyleScrap (hStyles: StScrpHandle;
  929.                                     hFontTable: WEFontTableHandle): OSErr;
  930.  
  931. { Script Manager utilities }
  932.  
  933.     FUNCTION WECharByte (offset: LONGINT;
  934.                                     we: WEReference): INTEGER;
  935.     FUNCTION WECharType (offset: LONGINT;
  936.                                     we: WEReference): INTEGER;
  937.  
  938. { Text Services Manager support }
  939.  
  940.     FUNCTION WEInstallTSMHandlers: OSErr;
  941.     FUNCTION WERemoveTSMHandlers: OSErr;
  942.     FUNCTION WEHandleTSMEvent ({CONST} VAR ae: AppleEvent;
  943.                                     VAR reply: AppleEvent): OSErr;
  944.     PROCEDURE WEStopInlineSession (we: WEReference);
  945.  
  946. { additional features }
  947.  
  948.     FUNCTION WEFeatureFlag (feature: INTEGER;
  949.                                     action: INTEGER;
  950.                                     we: WEReference): INTEGER;
  951.     FUNCTION WEGetInfo (selector: WESelector;
  952.                                     info: univ Ptr;
  953.                                     we: WEReference): OSErr;
  954.     FUNCTION WESetInfo (selector: WESelector;
  955.                                     info: univ Ptr;
  956.                                     we: WEReference): OSErr;
  957.  
  958. { getting and setting user-defined info }
  959.  
  960.     FUNCTION WEGetUserInfo (tag: WESelector;
  961.                                     VAR userInfo: LONGINT;
  962.                                     we: WEReference): OSErr;
  963.     FUNCTION WESetUserInfo (tag: WESelector;
  964.                                     userInfo: LONGINT;
  965.                                     we: WEReference): OSErr;
  966.  
  967. { long coordinates utility routines }
  968.  
  969.     PROCEDURE WELongPointToPoint ({CONST} VAR lp: LongPt;
  970.                                     VAR p: Point);
  971.     PROCEDURE WEPointToLongPoint (p: Point;
  972.                                     VAR lp: LongPt);
  973.     PROCEDURE WESetLongRect (VAR lr: LongRect;
  974.                                     left, top, right, bottom: LONGINT);
  975.     PROCEDURE WELongRectToRect ({CONST} VAR lr: LongRect;
  976.                                     VAR r: Rect);
  977.     PROCEDURE WERectToLongRect ({CONST} VAR r: Rect;
  978.                                     VAR lr: LongRect);
  979.     PROCEDURE WEOffsetLongRect (VAR lr: LongRect;
  980.                                     hOffset, vOffset: LONGINT);
  981.     FUNCTION WELongPointInLongRect ({CONST} VAR lp: LongPt;
  982.                                     {CONST} VAR lr: LongRect): BOOLEAN;
  983.  
  984. {$ALIGN RESET}
  985. {$POP}
  986.  
  987. IMPLEMENTATION
  988. END.